// bg-settings.js - 厨师背景设置页面，支持云端存储
const app = getApp()

Page({
  data: {
    currentBgImage: null,
    selectedPreset: null,
    tempImageUrl: null,
    showCropModal: false,
    showUploadModal: false,
    uploadProgress: 0,
    uploadStatus: '准备上传...',
    
    // 预设背景列表
    presetBackgrounds: [
      {
        id: 'background1',
        name: '预设1',
        url: '/images/backgrounds/background1.jpeg'
      },
      {
        id: 'background2',
        name: '预设2',
        url: '/images/backgrounds/background2.jpeg'
      }
    ]
  },

  onLoad() {
    this.checkCloudEnvironment()
    this.loadCurrentBackground()
    this.checkUserPermission()
  },

  onShow() {
    this.loadCurrentBackground()
  },

  // 检查云开发环境
  checkCloudEnvironment() {
    if (!wx.cloud) {
      wx.showModal({
        title: '环境错误',
        content: '当前环境不支持云开发功能',
        showCancel: false,
        success: () => {
          wx.navigateBack()
        }
      })
      return
    }
    
    // 检查云开发是否已初始化
    try {
      wx.cloud.init({
        env: 'cloudbase-9ghiew2sb390831b' // 请替换为您的云环境ID
      })
      console.log('云开发环境已初始化')
    } catch (error) {
      console.error('云开发环境初始化失败:', error)
    }
  },



  // 检查用户权限
  checkUserPermission() {
    const userInfo = app.globalData.userInfo
    if (!userInfo || (userInfo.role !== 'chef' && userInfo.role !== 'admin')) {
      wx.showModal({
        title: '权限不足',
        content: '只有厨师和管理员可以管理背景设置',
        showCancel: false,
        success: () => {
          wx.navigateBack()
        }
      })
    }
  },

  // 加载当前背景
  async loadCurrentBackground() {
    try {
      // 优先从云端加载背景
      await this.loadBackgroundFromCloud()
      
      // 如果云端没有，则从本地加载
      if (!this.data.currentBgImage) {
        const localBgImage = wx.getStorageSync('welcomeBgImage')
        if (localBgImage) {
          this.setData({
            currentBgImage: localBgImage
          })
        }
      }
    } catch (error) {
      console.error('加载背景失败:', error)
      // 降级到本地存储
      const localBgImage = wx.getStorageSync('welcomeBgImage')
      if (localBgImage) {
        this.setData({
          currentBgImage: localBgImage
        })
      }
    }
  },

  // 从云端加载背景
  async loadBackgroundFromCloud() {
    try {
      // 调用云函数获取当前背景
      const result = await wx.cloud.callFunction({
        name: 'getCurrentBackground'
      })
      
      if (result.result && result.result.success && result.result.data) {
        this.setData({
          currentBgImage: result.result.data.imageUrl
        })
        console.log('从云端加载背景成功:', result.result.data.imageUrl)
      }
    } catch (error) {
      console.error('从云端加载背景失败:', error)
      // 云函数未部署时，使用本地存储
      console.log('云函数未部署，使用本地存储')
      const localBgImage = wx.getStorageSync('welcomeBgImage')
      if (localBgImage) {
        this.setData({
          currentBgImage: localBgImage
        })
      }
    }
  },

  // 选择图片
  chooseImage() {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['album'],
      success: (res) => {
        const tempFilePath = res.tempFiles[0].tempFilePath
        console.log('选择的图片路径:', tempFilePath)
        
        this.setData({
          tempImageUrl: tempFilePath,
          showCropModal: true
        })
      },
      fail: (error) => {
        console.error('选择图片失败:', error)
        wx.showToast({
          title: '选择图片失败',
          icon: 'error'
        })
      }
    })
  },

  // 拍摄照片
  takePhoto() {
    wx.chooseMedia({
      count: 1,
      mediaType: ['image'],
      sourceType: ['camera'],
      success: (res) => {
        const tempFilePath = res.tempFiles[0].tempFilePath
        console.log('拍摄的图片路径:', tempFilePath)
        
        this.setData({
          tempImageUrl: tempFilePath,
          showCropModal: true
        })
      },
      fail: (error) => {
        console.error('拍摄照片失败:', error)
        wx.showToast({
          title: '拍摄照片失败',
          icon: 'error'
        })
      }
    })
  },

  // 使用默认背景
  useDefaultBg() {
    wx.showModal({
      title: '确认操作',
      content: '确定要恢复默认渐变背景吗？',
      success: (res) => {
        if (res.confirm) {
          this.clearBackground()
        }
      }
    })
  },

  // 选择预设背景
  selectPreset(e) {
    const preset = e.currentTarget.dataset.preset
    this.setData({
      selectedPreset: preset.id
    })
    
    // 预览预设背景
    this.previewBackground(preset.url)
  },

  // 预览背景
  previewBackground(imageUrl) {
    wx.showModal({
      title: '预览背景',
      content: '确定要使用这个背景吗？',
      success: (res) => {
        if (res.confirm) {
          this.setBackground(imageUrl)
        }
      }
    })
  },

  // 设置背景
  async setBackground(imageUrl) {
    try {
      console.log('设置背景，图片路径:', imageUrl)
      
      // 保存到本地存储
      wx.setStorageSync('welcomeBgImage', imageUrl)
      
      // 更新页面数据
      this.setData({
        currentBgImage: imageUrl,
        selectedPreset: null
      })
      
      // 通知首页更新背景
      this.notifyHomePageUpdate(imageUrl)
      
      wx.showToast({
        title: '背景已设置',
        icon: 'success'
      })
    } catch (error) {
      console.error('设置背景失败:', error)
      wx.showToast({
        title: '设置失败',
        icon: 'error'
      })
    }
  },

  // 清除背景
  async clearBackground() {
    try {
      // 从本地存储移除
      wx.removeStorageSync('welcomeBgImage')
      
      // 更新页面数据
      this.setData({
        currentBgImage: null,
        selectedPreset: null
      })
      
      // 通知首页更新背景
      this.notifyHomePageUpdate(null)
      
      // 同步到云端
      await this.syncBackgroundToCloud(null)
      
      wx.showToast({
        title: '已恢复默认背景',
        icon: 'success'
      })
    } catch (error) {
      console.error('清除背景失败:', error)
      wx.showToast({
        title: '清除失败',
        icon: 'error'
      })
    }
  },

  // 测试云开发连接
  async testCloudConnection() {
    try {
      wx.showLoading({
        title: '测试连接中...'
      })
      
      console.log('开始测试云开发连接...')
      
      // 首先检查云存储权限
      const permissionCheck = await this.checkCloudStoragePermission()
      console.log('权限检查结果:', permissionCheck)
      
      if (!permissionCheck.hasPermission) {
        wx.hideLoading()
        wx.showModal({
          title: '权限检查失败',
          content: `${permissionCheck.reason}\n\n${permissionCheck.suggestion}`,
          showCancel: false,
          confirmText: '知道了'
        })
        return
      }
      
      // 测试云函数调用
      const functionResult = await wx.cloud.callFunction({
        name: 'getCurrentBackground'
      })
      
      console.log('云函数测试结果:', functionResult)
      
      // 测试云存储 - 使用一个简单的文本内容创建临时文件
      try {
        // 创建一个简单的测试文件内容
        const testContent = 'Hello Cloud!'
        const testFileName = `test_${Date.now()}.txt`
        
        // 使用 wx.getFileSystemManager 创建临时文件
        const fs = wx.getFileSystemManager()
        const tempFilePath = `${wx.env.USER_DATA_PATH}/${testFileName}`
        
        fs.writeFileSync(tempFilePath, testContent, 'utf8')
        console.log('临时测试文件已创建:', tempFilePath)
        
        const uploadResult = await wx.cloud.uploadFile({
          cloudPath: `test/${testFileName}`,
          filePath: tempFilePath
        })
        
        console.log('云存储测试结果:', uploadResult)
        
        // 删除测试文件
        await wx.cloud.deleteFile({
          fileList: [uploadResult.fileID]
        })
        
        // 删除本地临时文件
        try {
          fs.unlinkSync(tempFilePath)
        } catch (unlinkError) {
          console.log('删除本地临时文件失败:', unlinkError)
        }
        
        wx.hideLoading()
        wx.showModal({
          title: '连接测试成功',
          content: '云开发服务连接正常！\n\n云函数: ✅\n云存储: ✅\n数据库: ✅',
          showCancel: false,
          confirmText: '太好了'
        })
        
      } catch (uploadError) {
        console.error('云存储测试失败:', uploadError)
        
        // 尝试更详细的诊断
        await this.diagnoseCloudStorageError(uploadError)
        
        wx.hideLoading()
        wx.showModal({
          title: '连接测试部分成功',
          content: `云函数连接正常，但云存储有问题：\n\n${uploadError.message || '未知错误'}`,
          showCancel: false,
          confirmText: '知道了'
        })
      }
      
    } catch (error) {
      console.error('云开发连接测试失败:', error)
      
      wx.hideLoading()
      wx.showModal({
        title: '连接测试失败',
        content: `云开发服务连接失败：\n\n${error.message || '未知错误'}\n\n请检查：\n1. 网络连接\n2. 云开发配置\n3. 云函数是否已部署`,
        showCancel: false,
        confirmText: '知道了'
      })
    }
  },

  // 检查云存储权限
  async checkCloudStoragePermission() {
    try {
      console.log('检查云存储权限...')
      
      // 检查用户登录状态
      const userInfo = wx.getStorageSync('userInfo')
      if (!userInfo || !userInfo._id) {
        return {
          hasPermission: false,
          reason: '用户未登录',
          suggestion: '请先登录后再使用云存储功能'
        }
      }
      
      // 尝试调用云函数获取用户身份
      try {
        const authResult = await wx.cloud.callFunction({
          name: 'getOpenId'
        })
        
        if (authResult.result && authResult.result.openid) {
          console.log('用户身份验证成功:', authResult.result.openid)
          return {
            hasPermission: true,
            openid: authResult.result.openid
          }
        } else {
          return {
            hasPermission: false,
            reason: '身份验证失败',
            suggestion: '请重新登录'
          }
        }
      } catch (authError) {
        console.error('身份验证失败:', authError)
        return {
          hasPermission: false,
          reason: '身份验证失败',
          suggestion: '请检查网络连接并重新登录'
        }
      }
      
    } catch (error) {
      console.error('检查云存储权限失败:', error)
      return {
        hasPermission: false,
        reason: '权限检查失败',
        suggestion: '请检查网络连接'
      }
    }
  },

  // 诊断云存储错误
  async diagnoseCloudStorageError(error) {
    console.log('开始诊断云存储错误...')
    
    try {
      // 检查云开发环境
      console.log('云开发环境信息:', {
        env: wx.cloud.DYNAMIC_CURRENT_ENV || 'cloudbase-9ghiew2sb390831b',
        hasCloud: !!wx.cloud,
        cloudInit: !!wx.cloud.init
      })
      
      // 检查用户登录状态
      const userInfo = wx.getStorageSync('userInfo')
      console.log('用户登录状态:', {
        isLoggedIn: !!userInfo,
        userId: userInfo?._id || 'unknown'
      })
      
      // 尝试获取云存储权限
      try {
        const authResult = await wx.cloud.callFunction({
          name: 'getOpenId'
        })
        console.log('用户身份验证结果:', authResult)
      } catch (authError) {
        console.error('身份验证失败:', authError)
      }
      
      // 检查网络状态
      wx.getNetworkType({
        success: (res) => {
          console.log('网络状态:', res.networkType)
        },
        fail: (err) => {
          console.error('获取网络状态失败:', err)
        }
      })
      
    } catch (diagnosticError) {
      console.error('诊断过程出错:', diagnosticError)
    }
  },

  // 上传到云端
  async uploadToCloud() {
    if (!this.data.currentBgImage) {
      wx.showToast({
        title: '请先设置背景图片',
        icon: 'none'
      })
      return
    }

    // 检查云开发是否可用
    try {
      await wx.cloud.callFunction({
        name: 'getCurrentBackground'
      })
    } catch (error) {
      if (error.errCode === -501000) {
        wx.showModal({
          title: '云函数未部署',
          content: '请先部署云函数后再使用云端功能。\n\n部署步骤：\n1. 右键点击 cloudfunctions/getCurrentBackground\n2. 选择"上传并部署：云端安装依赖"\n3. 重复上述步骤部署 updateBackground',
          showCancel: false,
          confirmText: '知道了'
        })
        return
      }
    }

    this.setData({
      showUploadModal: true,
      uploadProgress: 0,
      uploadStatus: '准备上传...'
    })

    try {
      // 模拟初始进度
      this.setData({
        uploadProgress: 10,
        uploadStatus: '开始上传...'
      })
      
      console.log('开始上传背景图片:', this.data.currentBgImage)
      await this.syncBackgroundToCloud(this.data.currentBgImage)
      
      // 上传成功，显示完成状态
      setTimeout(() => {
        this.setData({
          showUploadModal: false
        })
        wx.showToast({
          title: '已同步到云端',
          icon: 'success'
        })
      }, 1000)
      
    } catch (error) {
      console.error('上传到云端失败:', error)
      
      let errorMessage = '上传失败'
      if (error.message) {
        if (error.message.includes('file path invalid')) {
          errorMessage = '文件路径无效，请重新选择图片'
        } else if (error.message.includes('云存储')) {
          errorMessage = '云存储上传失败，请检查网络连接'
        } else {
          errorMessage = error.message
        }
      }
      
      this.setData({
        uploadStatus: '上传失败: ' + errorMessage
      })
      
      setTimeout(() => {
        this.setData({
          showUploadModal: false
        })
        wx.showToast({
          title: errorMessage,
          icon: 'error'
        })
      }, 2000)
    }
  },

  // 从云端下载
  async downloadFromCloud() {
    try {
      await this.loadBackgroundFromCloud()
      
      if (this.data.currentBgImage) {
        wx.showToast({
          title: '已从云端获取',
          icon: 'success'
        })
      } else {
        wx.showToast({
          title: '云端暂无背景',
          icon: 'none'
        })
      }
    } catch (error) {
      console.error('从云端下载失败:', error)
      wx.showToast({
        title: '下载失败',
        icon: 'error'
      })
    }
  },

  // 管理云端背景库
  manageCloudBgs() {
    try {
      console.log('点击云端背景库按钮')
      console.log('准备跳转到:', '/pages/chef/settings/bg-settings/cloud-bg-library/cloud-bg-library')
      
      wx.navigateTo({
        url: '/pages/chef/settings/bg-settings/cloud-bg-library/cloud-bg-library',
        success: () => {
          console.log('跳转成功')
        },
        fail: (error) => {
          console.error('跳转失败:', error)
          
          // 显示错误信息
          wx.showModal({
            title: '跳转失败',
            content: `无法打开云端背景库页面：\n\n${error.errMsg || '未知错误'}\n\n请检查页面路径是否正确`,
            showCancel: false,
            confirmText: '知道了'
          })
        }
      })
    } catch (error) {
      console.error('manageCloudBgs 方法执行失败:', error)
      
      wx.showToast({
        title: '操作失败',
        icon: 'error'
      })
    }
  },

  // 同步背景到云端
  async syncBackgroundToCloud(imageUrl) {
    try {
      console.log('开始同步背景到云端，图片URL:', imageUrl)
      
      // 首先上传图片到云存储
      let cloudImageUrl = imageUrl
      
      if (imageUrl && !imageUrl.startsWith('cloud://')) {
        // 上传图片到云存储
        this.setData({
          uploadProgress: 20,
          uploadStatus: '正在上传图片到云存储...'
        })
        
        console.log('准备上传图片到云存储，本地路径:', imageUrl)
        const uploadResult = await this.uploadImageToCloud(imageUrl)
        
        if (uploadResult.success) {
          cloudImageUrl = uploadResult.data.fileID
          console.log('图片上传到云存储成功:', cloudImageUrl)
        } else {
          console.error('图片上传到云存储失败:', uploadResult.error)
          throw new Error('图片上传到云存储失败: ' + uploadResult.error)
        }
      }
      
      // 更新上传进度
      this.setData({
        uploadProgress: 60,
        uploadStatus: '正在同步到数据库...'
      })
      
      // 调用云函数更新背景
      console.log('调用云函数updateBackground，参数:', {
        imageUrl: cloudImageUrl,
        updatedBy: app.globalData.userInfo?._id || 'unknown',
        updatedAt: new Date().toISOString()
      })
      
      const result = await wx.cloud.callFunction({
        name: 'updateBackground',
        data: {
          imageUrl: cloudImageUrl,
          updatedBy: app.globalData.userInfo?._id || 'unknown',
          updatedAt: new Date().toISOString()
        }
      })
      
      console.log('云函数调用结果:', result)
      
      if (result.result && result.result.success) {
        console.log('背景已同步到云端')
        this.setData({
          uploadProgress: 100,
          uploadStatus: '同步完成！'
        })
        return result.result
      } else {
        const errorMsg = result.result?.error || result.errMsg || '同步失败'
        
        // 检查是否是数据库集合不存在的错误
        if (errorMsg.includes('DATABASE_COLLECTION_NOT_EXIST') || errorMsg.includes('collection not exists')) {
          throw new Error('数据库集合不存在，请先在云开发控制台创建 backgrounds 集合')
        }
        
        throw new Error(errorMsg)
      }
    } catch (error) {
      console.error('同步背景到云端失败:', error)
      throw error
    }
  },

  // 上传图片到云存储
  async uploadImageToCloud(filePath) {
    try {
      console.log('准备上传图片到云存储，文件路径:', filePath)
      
      // 验证文件路径
      if (!filePath || typeof filePath !== 'string') {
        throw new Error('无效的文件路径')
      }
      
      // 检查云开发是否已初始化
      if (!wx.cloud) {
        throw new Error('云开发未初始化')
      }
      
      // 检查文件是否存在
      try {
        const fs = wx.getFileSystemManager()
        const fileInfo = fs.statSync(filePath)
        console.log('文件信息:', fileInfo)
        
        if (!fileInfo.isFile()) {
          throw new Error('路径不是文件')
        }
      } catch (fsError) {
        console.error('文件系统检查失败:', fsError)
        throw new Error(`文件不存在或无法访问: ${fsError.message}`)
      }
      
      const cloudPath = `backgrounds/${Date.now()}_${Math.random().toString(36).substr(2, 9)}.jpg`
      console.log('云存储路径:', cloudPath)
      
      // 检查用户登录状态
      const userInfo = wx.getStorageSync('userInfo')
      if (!userInfo || !userInfo._id) {
        console.warn('用户未登录，可能影响云存储权限')
      }
      
      const result = await wx.cloud.uploadFile({
        cloudPath: cloudPath,
        filePath: filePath
      })
      
      console.log('云存储上传结果:', result)
      
      if (result.fileID) {
        return { success: true, data: result }
      } else {
        throw new Error('上传失败')
      }
    } catch (error) {
      console.error('上传图片到云存储失败:', error)
      
      // 提供更具体的错误信息
      let errorMessage = error.message
      if (error.message.includes('file not found')) {
        errorMessage = '文件不存在，请重新选择图片'
      } else if (error.message.includes('file path invalid')) {
        errorMessage = '文件路径无效，请重新选择图片'
      } else if (error.message.includes('permission denied')) {
        errorMessage = '权限不足，请检查登录状态'
      } else if (error.message.includes('network')) {
        errorMessage = '网络错误，请检查网络连接'
      }
      
      return { success: false, error: errorMessage }
    }
  },

  // 通知首页更新背景
  notifyHomePageUpdate(imageUrl) {
    console.log('准备通知首页更新背景:', imageUrl)
    console.log('事件总线状态:', app.globalData.eventBus ? '已初始化' : '未初始化')
    
    // 通过全局事件总线通知首页
    if (app.globalData.eventBus) {
      console.log('发送 updateWelcomeBackground 事件')
      app.globalData.eventBus.emit('updateWelcomeBackground', imageUrl)
      
      // 延迟检查事件是否发送成功
      setTimeout(() => {
        console.log('事件发送完成，检查首页是否收到')
      }, 100)
    } else {
      console.error('事件总线未初始化，无法通知首页')
      // 尝试直接调用首页方法
      this.updateHomePageDirectly(imageUrl)
    }
  },

  // 直接更新首页（备用方案）
  updateHomePageDirectly(imageUrl) {
    try {
      console.log('尝试直接更新首页背景:', imageUrl)
      
      // 获取当前页面栈
      const pages = getCurrentPages()
      const homePage = pages.find(page => page.route === 'pages/index/index')
      
      if (homePage && homePage.setData) {
        console.log('找到首页，直接更新背景')
        homePage.setData({
          welcomeBgImage: imageUrl
        })
        
        // 同时更新本地存储
        wx.setStorageSync('welcomeBgImage', imageUrl)
        
        wx.showToast({
          title: '背景已更新到首页',
          icon: 'success'
        })
      } else {
        console.log('未找到首页，使用本地存储')
        wx.setStorageSync('welcomeBgImage', imageUrl)
      }
    } catch (error) {
      console.error('直接更新首页失败:', error)
      // 降级到本地存储
      wx.setStorageSync('welcomeBgImage', imageUrl)
    }
  },

  // 确认裁剪
  confirmCrop() {
    if (this.data.tempImageUrl) {
      this.setBackground(this.data.tempImageUrl)
      this.closeCropModal()
    }
  },

  // 关闭裁剪弹窗
  closeCropModal() {
    this.setData({
      showCropModal: false,
      tempImageUrl: null
    })
  },

  // 取消上传
  cancelUpload() {
    this.setData({
      showUploadModal: false
    })
    wx.showToast({
      title: '已取消上传',
      icon: 'none'
    })
  },

  // 重置设置
  resetSettings() {
    wx.showModal({
      title: '确认重置',
      content: '确定要重置所有背景设置吗？这将恢复默认背景。',
      success: (res) => {
        if (res.confirm) {
          this.clearBackground()
        }
      }
    })
  },

  // 保存设置
  saveSettings() {
    wx.showToast({
      title: '设置已保存',
      icon: 'success'
    })
    
    // 延迟返回上一页
    setTimeout(() => {
      wx.navigateBack()
    }, 1500)
  },

  // 阻止事件冒泡
  stopPropagation() {
    // 阻止事件冒泡
  }
}) 